// 导入类型定义
import { ErrorInfo, PerformanceInfo, BehaviorInfo } from '../types'; // 导入相关类型

// 生成唯一ID
export function generateId(): string {
  return Math.random().toString(36).substr(2, 9) + Date.now().toString(36); // 随机字符串+时间戳
}

// 生成会话ID，存储在sessionStorage
export function generateSessionId(): string {
  const sessionId = sessionStorage.getItem('error_monitor_session_id'); // 获取已有会话ID
  if (sessionId) {
    return sessionId; // 已有则直接返回
  }
  const newSessionId = generateId(); // 生成新ID
  sessionStorage.setItem('error_monitor_session_id', newSessionId); // 存储到sessionStorage
  return newSessionId; // 返回新ID
}

// 获取元素选择器
export function getElementSelector(element: Element): string {
  if (element.id) {
    return `#${element.id}`; // 有id优先用id
  }
  if (element.className) {
    const classes = element.className.split(' ').filter(Boolean); // 拆分class
    if (classes.length > 0) {
      return `.${classes.join('.')}`; // 用class拼接
    }
  }
  if (element.tagName) {
    return element.tagName.toLowerCase(); // 用标签名
  }
  return 'unknown'; // 无法识别
}

// 获取元素文本内容
export function getElementText(element: Element): string {
  const text = element.textContent || (element as HTMLElement).innerText || ''; // 获取文本
  return text.trim().substring(0, 100); // 截取前100字符
}

// 获取当前页面URL
export function getCurrentUrl(): string {
  return window.location.href; // 直接返回location
}

// 获取用户代理
export function getUserAgent(): string {
  return navigator.userAgent; // 直接返回userAgent
}

// 获取浏览器信息
export function getBrowserInfo() {
  const ua = navigator.userAgent; // 获取UA
  const browser = {
    name: 'unknown', // 浏览器名
    version: 'unknown', // 版本
    os: 'unknown' // 操作系统
  };
  // 检测浏览器
  if (ua.includes('Chrome')) {
    browser.name = 'Chrome';
  } else if (ua.includes('Firefox')) {
    browser.name = 'Firefox';
  } else if (ua.includes('Safari')) {
    browser.name = 'Safari';
  } else if (ua.includes('Edge')) {
    browser.name = 'Edge';
  } else if (ua.includes('MSIE') || ua.includes('Trident')) {
    browser.name = 'IE';
  }
  // 检测操作系统
  if (ua.includes('Windows')) {
    browser.os = 'Windows';
  } else if (ua.includes('Mac')) {
    browser.os = 'Mac';
  } else if (ua.includes('Linux')) {
    browser.os = 'Linux';
  } else if (ua.includes('Android')) {
    browser.os = 'Android';
  } else if (ua.includes('iOS')) {
    browser.os = 'iOS';
  }
  return browser; // 返回信息
}

// 获取屏幕信息
export function getScreenInfo() {
  return {
    width: screen.width, // 屏幕宽度
    height: screen.height, // 屏幕高度
    availWidth: screen.availWidth, // 可用宽度
    availHeight: screen.availHeight, // 可用高度
    colorDepth: screen.colorDepth, // 颜色深度
    pixelDepth: screen.pixelDepth // 像素深度
  };
}

// 获取网络信息
export function getNetworkInfo() {
  const connection = (navigator as any).connection || (navigator as any).mozConnection || (navigator as any).webkitConnection; // 兼容不同浏览器
  return {
    effectiveType: connection?.effectiveType || 'unknown', // 网络类型
    downlink: connection?.downlink || 0, // 下行速率
    rtt: connection?.rtt || 0, // 往返时延
    saveData: connection?.saveData || false // 是否省流
  };
}

// 深度克隆对象
export function deepClone<T>(obj: T): T {
  if (obj === null || typeof obj !== 'object') {
    return obj; // 基本类型直接返回
  }
  if (obj instanceof Date) {
    return new Date(obj.getTime()) as any; // 克隆日期
  }
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item)) as any; // 克隆数组
  }
  if (typeof obj === 'object') {
    const cloned = {} as any; // 新对象
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        cloned[key] = deepClone(obj[key]); // 递归克隆
      }
    }
    return cloned;
  }
  return obj; // 兜底
}

// 节流函数
export function throttle<T extends (...args: any[]) => any>(
  func: T,
  delay: number
): (...args: Parameters<T>) => void {
  let timeoutId: ReturnType<typeof setTimeout> | null = null; // 定时器ID
  let lastExecTime = 0; // 上次执行时间
  return (...args: Parameters<T>) => {
    const currentTime = Date.now(); // 当前时间
    if (currentTime - lastExecTime > delay) {
      func(...args); // 立即执行
      lastExecTime = currentTime; // 更新时间
    } else {
      if (timeoutId) {
        clearTimeout(timeoutId); // 清除旧定时器
      }
      timeoutId = setTimeout(() => {
        func(...args); // 延迟执行
        lastExecTime = Date.now(); // 更新时间
      }, delay - (currentTime - lastExecTime));
    }
  };
}

// 防抖函数
export function debounce<T extends (...args: any[]) => any>(
  func: T,
  delay: number
): (...args: Parameters<T>) => void {
  let timeoutId: ReturnType<typeof setTimeout> | null = null; // 定时器ID
  return (...args: Parameters<T>) => {
    if (timeoutId) {
      clearTimeout(timeoutId); // 清除旧定时器
    }
    timeoutId = setTimeout(() => {
      func(...args); // 延迟执行
    }, delay);
  };
}

// 格式化错误堆栈
export function formatErrorStack(error: Error): string {
  if (!error.stack) {
    return ''; // 无堆栈返回空
  }
  return error.stack
    .split('\n') // 按行分割
    .slice(0, 10) // 只取前10行
    .join('\n'); // 合并为字符串
}

// 判断是否为采样数据
export function shouldSample(sampleRate: number = 1): boolean {
  return Math.random() < sampleRate; // 随机采样
}

// 获取性能指标
export function getPerformanceMetrics(): Partial<PerformanceInfo> {
  const metrics: Partial<PerformanceInfo> = {}; // 初始化结果
  if (window.performance && window.performance.timing) {
    const timing = window.performance.timing; // 获取性能时序
    metrics.loadTime = timing.loadEventEnd - timing.navigationStart; // 页面加载时间
    metrics.domContentLoadedTime = timing.domContentLoadedEventEnd - timing.navigationStart; // DOM加载时间
  }
  // 获取Web Vitals指标
  if ('PerformanceObserver' in window) {
    // FCP (首次内容绘制)
    try {
      const fcpObserver = new PerformanceObserver((list) => {
        const entries = list.getEntries();
        if (entries.length > 0) {
          metrics.fcp = entries[0].startTime; // 记录FCP
        }
      });
      fcpObserver.observe({ entryTypes: ['paint'] });
    } catch (e) {
      // 忽略错误
    }
    // LCP (最大内容绘制)
    try {
      const lcpObserver = new PerformanceObserver((list) => {
        const entries = list.getEntries();
        if (entries.length > 0) {
          const lastEntry = entries[entries.length - 1];
          metrics.lcp = lastEntry.startTime; // 记录LCP
        }
      });
      lcpObserver.observe({ entryTypes: ['largest-contentful-paint'] });
    } catch (e) {
      // 忽略错误
    }
    // FID (首次输入延迟)
    try {
      const fidObserver = new PerformanceObserver((list) => {
        const entries = list.getEntries();
        if (entries.length > 0) {
          const entry = entries[0] as any;
          metrics.fid = entry.processingStart - entry.startTime; // 记录FID
        }
      });
      fidObserver.observe({ entryTypes: ['first-input'] });
    } catch (e) {
      // 忽略错误
    }
    // CLS (累积布局偏移)
    try {
      const clsObserver = new PerformanceObserver((list) => {
        let clsValue = 0;
        for (const entry of list.getEntries()) {
          if (!(entry as any).hadRecentInput) {
            clsValue += (entry as any).value; // 累加CLS
          }
        }
        metrics.cls = clsValue; // 记录CLS
      });
      clsObserver.observe({ entryTypes: ['layout-shift'] });
    } catch (e) {
      // 忽略错误
    }
  }
  return metrics; // 返回性能指标
} 